NetNews Offline 2/NetNews Offline Volume 2.iso/news/comp/lang/c++-part1/4237

Text File | 1996-08-06 | 5.1 KB | 179 lines

Path: ix.netcom.com!netnews
From: [e-mail](Michael Arrington )
Newsgroups: comp.lang.c++
Subject: C++ help--probably a simple answer (short listing attached)
Date: 29 Jan 1996 03:07:01 GMT
Organization: Netcom
Message-ID: <4ehdkl$[e-mail]>
NNTP-Posting-Host: mon-ca5-12.ix.netcom.com
X-NETCOM-Date: Sun Jan 28  7:07:01 PM PST 1996

Hi,

I have a question about C++.  I'm just learning C++ but I've been
writing programs in other languages for a number of years.  In this
problem, I'm creating a class to represent a 2D cellular automaton
(like Conway's Life). Here's the (partial) declaration and
implementation of the class:

*******************
****FROM CELL.H****
*******************

class CCellAuto
{
public:
    // Public constructors & destructors
    CCellAuto();                                // Default constructor
    CCellAuto(int xSize, int ySize);            // Overloaded
Constructor
    ~CCellAuto();                               // Default Destructor
    // Public accessor methods
    void BumpGen();
    void BumpPop();
    int GetGen() const;
    int GetPop() const;
    void RandomizeCells();
    void SetRules(int deathLow, int deathHigh, int birthLow, int
birthHigh);
    void UpdateCells();
    void ResizeArrays(int xSize, int ySize);

private:
    // Private data members
    int xSize;              // X dimension of arrays
    int ySize;              // Y dimension of arrays
    int cell[1][1];         // Array holding live cells
    int old[1][1];          // Temp array
    int deathLow;           // Birth/Death rules
    int deathHigh;
    int birthLow;
    int birthHigh;
    int currGen;            // # of current generation
    int currPop;            // # of cells alive
    int wrap;               // Wrap to other side of array?
};

*********************
****FROM CELL.CPP****
*********************

// Default constructor
CCellAuto::CCellAuto()
{
    wrap = 1;                           // Set wrap to on
    currPop = 0;                        // Initialize currPopulation
    currGen = 1;                        // Initialize currGeneration
    ResizeArrays(10, 10);               // Set default array size
    SetRules(2, 4, 2, 4);               // Set default rules
    RandomizeCells();                   // Randomize cells
}

// Overloaded Constructor
CCellAuto::CCellAuto(int x, int y)
{
    wrap = 1;                           // Set wrap to on
    currPop = 0;                        // Initialize currPopulation
    currGen = 1;                        // Initialize currGeneration
    ResizeArrays(x, y);                 // Size arrays to X by Y
    SetRules(2, 4, 2, 4);               // Set default rules
    RandomizeCells();                   // Randomize cells
}

// Default Destructor
CCellAuto::~CCellAuto()
{
}

// BumpGen()
void CCellAuto::BumpGen()
{
    currGen++;
}

// BumpPop()
void CCellAuto::BumpPop()
{
    currPop++;
}

// GetGen()
int CCellAuto::GetGen() const
{
    return currGen;
}

// GetPop()
int CCellAuto::GetPop() const
{
    return currPop;
}

// RandomizeCells()
void CCellAuto::RandomizeCells()
{
     // Omitted...Randomly sets cell[][] elements to either 1 or 0
}

// ResizeArrays()
void CCellAuto::ResizeArrays(int x, int y)
{
     // Omitted...Sets cell[][] and old[][] to dimensions x and y
}

// SetRules()
void CCellAuto::SetRules(int a, int b, int c, int d)
{
    deathLow = a;
    deathHigh = b;
    birthLow = c;
    birthHigh = d;
}

// UpdateCells()
void CCellAuto::UpdateCells()
{
     // Omitted...copies cell[][] to old[][] and creates next iteration
     // in new[][].  Calls BumpGen() when done.
}

Whew!  I omitted a lot of that...but I wanted to give enough to let you
see any problems I might have created in it.  Now, when I declare a
CCellAuto object [[like this -- CCellAuto *Life1 = new CCellAuto(20,
20); ]]and try to access a member function [[like this -- cout <<
Life1->GetPop() << endl; ]] I get uninitialized variables.  That's
weird because I initialize them in the constructor.  Now, if I were to
call Life1->BumpPop() first...the GetPop() function returns the correct
number.  Why?  Here's my main() listing:

*********************
****FROM LIFE.CPP****
*********************

01   void main()
02   {
03       CCellAuto *Life1 = new CCellAuto(20,20);
04       if (Life1 == 0)
05           cout << "cannot allocate memory\n";
06       //Life1->BumpPop();
07       cout << "Life1 Pop: " << Life1->GetPop() << endl;
08       cout << "Life1 Gen: " << Life1->GetGen() << endl;
09       delete Life1;
10   }


As listed, lines 07 and 08 return 0 values for currPop and currGen.  If
you remove the comment marks from line 06, line 07 will return the
actual (albeit incremented) value of 1. I have no idea what is going on
here.  I don't think it's my logic--I've written this same program
before in BASIC and some other languages.  Any suggestions as to what's
going on?  Please help!

If you have any answers, please e-mail to [e-mail] unless
you feel it would be beneficial to the forum.  Thanks in advance for
your help.

Mike

BTW:  I'm using MSC++ v7.0 if that's a help.